package Demo08.Demo0823;
// 这一节是关于【数组】的预习的


public class Prepare {
    public static void main(String[] args) {
        //数组转字符串
        /* int[] arr = {1,2,3,4,5,6};
        String str = Arrays.toString(arr);
        System.out.println(str);*/ // Arrays.toString()  这个是位于 java.util.Arrays包下的
        //这里的话，自己尝试深拷贝和浅拷贝
        /*//浅拷贝
        int[] arr1 = {1,2,3,4,5,6};
        int[] arr2 = arr1;
        arr2[0] = 10;
        System.out.println(Arrays.toString(arr1));//看一看对于arr2的修改是否会影响到arr1，实际上确实影响到了
        arr1[0] = 1;//初始化arr1数组
        //深拷贝
        arr2 = Arrays.copyOf(arr1,arr1.length);
        arr2[0] = 10;
        System.out.println(Arrays.toString(arr1));
        System.out.println(Arrays.toString(arr2));//事实证明这里开辟了新的内存空间创建了新的对象，所以两个互不影响
        //尝试片段拷贝
        int[] arr3 = Arrays.copyOfRange(arr1,2,4);//这里的拷贝是 [2,4),是这样子的
        System.out.println(Arrays.toString(arr3));*/
        //这里的话自己写一个浅拷贝方法
        /* int[] a = {1,2,3,4,5};
        int[] arr = copy(a);
        System.out.println(Arrays.toString(arr));*/
        //求数组元素中的平均值
        /* int[] a = new int[]{1,2,3,4,5};
        System.out.println(avg(a));*/
        //查找数组元素
        /* int[] a = {53,6,8,2,1,3,5,4,8};
        int key = 5;
        System.out.println(search(a,key));*/
        //查找有序数组中指定元素的位置（二分查找）
       /* int[] a = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
        int key = 36;
        System.out.println(binarySearch(a,key));*/
        //冒泡排序
       /* int[] a = new int[]{7,6,5,4,3,2,1};
        System.out.println(Arrays.toString(bubbleSort(a)));*/
        //将数组里面元素逆序排列
        /*int[] a = {7,6,5,4,3,2,1};
        System.out.println(Arrays.toString(reverse(a)));*/
    }
    public static int[] reverse(int[] a){
        int left = 0,right = a.length - 1;
        while(left < right){
            int tmp =  a[left];
            a[left] = a[right];
            a[right] = tmp;
            left++;
            right--;
        }
        return a;
    }
    public static int[] bubbleSort(int[] a){
        for(int i = 1;i < a.length;i++){ //控制排列次数,一共排六次
            for (int j = 0; j < a.length-i;j++){ //控制排序过程，每一次排序都可以减少和后面排的一位
              if(a[j] > a[j + 1]){
                  int tmp = a[j];
                  a[j] = a[j + 1];
                  a[j + 1] = tmp;
              }
            }
        }
        return a;
    } //冒泡排序
    public static int binarySearch(int[] a,int key){
        /*int left = 0,right = a.length - 1; //设立左右标
        while(true){
            int mid =(left + right) / 2; //设置 binary查找的中间值
            if(key > a[mid]){ // 如果key大于中间值，那么在右边区域查找
                left = mid;
            }else if( key < a[mid]){//  如果 key 小于 中间值，那么在左边区域查找
                right = mid;
            }else if(key == a[mid]){ //如果相等就是找到了
                return mid;
            }else{
                return -1;
            }
        }//这里的话，我对while（）循环的判断条件是true,如果最后找到，就直接返回了，没有考虑没找到的情况
        这里的话，不能这样子写，因为到了最后就变成小数不断求值了
        */
        int left = 0,right = a.length - 1; //设立左右标
        while(left <= right){
            int mid =(left + right) / 2; //设置 binary查找的中间值
            if(key > a[mid]){ // 如果key大于中间值，那么在右边区域查找
                left = mid + 1;
            }else if( key < a[mid]){//  如果 key 小于 中间值，那么在左边区域查找
                right = mid - 1;
            }else { //如果相等就是找到了
                return mid;
            }
        }
        return -1;
    } //二分法查找
    public static int search(int[] a,int key){
        for (int i = 0; i < a.length; i++) {
            if(a[i] == key){
                return i;
            }
        }
        return -1;
    }//查找数组中元素的位置
    public static double avg(int[] a){
        int res = 0;//接收数值总和
        double avg = 0;//用来求平均值
        for(int i:a){
            res += i;
        }
        avg = res / a.length;
        return avg;
    }  //求数组平均值
    public static int[] copy(int[] a){
        int[] b = new int[a.length];
        for(int i = 0;i < a.length;i++){
            b[i] = a[i];
        }
        return b;
    }  //深拷贝数组

}
